const { app, BrowserWindow, Menu, ipcMain, shell, dialog } = require('electron');
const path = require('path');
const fs = require('fs').promises;
// 判断当前是否为开发环境
// process.env.NODE_ENV 是 Node.js 中的环境变量
// 当其值为 'development' 时表示开发环境，否则为生产环境
// 这个变量通常在启动脚本中设置，如 package.json 的 scripts 中
const isDev = process.env.NODE_ENV === 'development';

// 添加命令行参数来解决GPU相关问题和提升性能
if (process.platform === 'darwin') {
  // macOS特定优化
  app.commandLine.appendSwitch('disable-gpu-sandbox');
  app.commandLine.appendSwitch('enable-gpu-rasterization');
  app.commandLine.appendSwitch('enable-zero-copy');
} else {
  // 其他平台保持原有设置
  app.commandLine.appendSwitch('disable-gpu-sandbox');
  app.commandLine.appendSwitch('disable-software-rasterizer');
  app.commandLine.appendSwitch('disable-gpu');
}
app.commandLine.appendSwitch('no-sandbox');
app.commandLine.appendSwitch('disable-dev-shm-usage');
app.commandLine.appendSwitch('disable-background-timer-throttling');
app.commandLine.appendSwitch('disable-renderer-backgrounding');
app.commandLine.appendSwitch('disable-backgrounding-occluded-windows');

// 设置环境变量 production or development
if (isDev) {
  process.env.NODE_ENV = 'development';
}

// 保持对window对象的全局引用
let mainWindow;

function createWindow() {
  // 如果窗口已存在，先销毁
  if (mainWindow && !mainWindow.isDestroyed()) {
    mainWindow.destroy();
    mainWindow = null;
  }
  
  // 创建浏览器窗口
  mainWindow = new BrowserWindow({
    width: 1450,
    height: 850,
    minWidth: 1450,
    minHeight: 850,
    maxWidth: 1450,
    maxHeight: 850,
    webPreferences: {
      nodeIntegration: false,
      contextIsolation: true,
      enableRemoteModule: false,
      preload: path.join(__dirname, 'preload.js'),
      // 性能优化
      backgroundThrottling: false,
      offscreen: false,
      spellcheck: false
    },
    icon: path.join(__dirname, '../src/assets/logo.png'),
    show: false,
    frame: false, // 无边框窗口
    titleBarStyle: 'hidden',
    // macOS特定优化
    ...(process.platform === 'darwin' && {
      vibrancy: 'under-window',
      visualEffectState: 'active'
    })
  });

  // 根据环境加载不同的URL
  if (isDev) {
    mainWindow.loadURL('http://localhost:8080');
    // 开发模式下打开开发者工具
    mainWindow.webContents.openDevTools();
  } else {
    mainWindow.loadFile(path.join(__dirname, '../dist/index.html'));
  }

  // 窗口准备好后显示
  mainWindow.once('ready-to-show', () => {
    mainWindow.show();
    
    // 聚焦窗口
    if (isDev) {
      mainWindow.focus();
    }
  });

  // 当窗口被关闭时触发
  mainWindow.on('closed', () => {
    mainWindow = null;
    // 强制垃圾回收
    if (global.gc) {
      global.gc();
    }
  });
  
  // 窗口即将关闭时的处理
  mainWindow.on('close', async (event) => {
    // 阻止默认关闭行为，先进行数据同步
    event.preventDefault();
    
    try {
      console.log('窗口关闭时触发数据同步...');
      
      // 发送同步请求到渲染进程并等待响应
      mainWindow.webContents.send('sync-before-quit');
      
      // 等待渲染进程完成同步
      const syncResult = await new Promise((resolve) => {
        const timeout = setTimeout(() => {
          console.warn('同步超时，强制关闭窗口');
          resolve({ success: false, error: 'timeout' });
        }, 5000); // 5秒超时
        
        ipcMain.once('sync-before-quit-complete', (event, result) => {
          clearTimeout(timeout);
          resolve(result);
        });
      });
      
      console.log('窗口关闭时同步结果:', syncResult);
    } catch (error) {
      console.error('窗口关闭时同步失败:', error);
    }
    
    // 清理工作
    if (isDev) {
      mainWindow.webContents.closeDevTools();
    }
    
    // 移除所有监听器避免重复触发
    mainWindow.removeAllListeners('close');
    
    // 现在真正关闭窗口
     mainWindow.destroy();
   });

  // 处理外部链接
  mainWindow.webContents.setWindowOpenHandler(({ url }) => {
    shell.openExternal(url);
    return { action: 'deny' };
  });
}

// Electron初始化完成时创建窗口
app.whenReady().then(() => {
  createWindow();
  createMenu();

  app.on('activate', () => {
    // 在macOS上，当点击dock图标且没有其他窗口打开时，重新创建窗口
    if (BrowserWindow.getAllWindows().length === 0) {
      createWindow();
    }
  });
});

// 当所有窗口都关闭时退出应用
app.on('window-all-closed', () => {
  // 开发模式下强制退出，避免进程残留
  if (isDev) {
    app.quit();
    return;
  }
  
  // 在macOS上，应用通常会保持活跃状态
  if (process.platform !== 'darwin') {
    app.quit()
  }
});

// IPC处理程序
ipcMain.handle('app-version', () => {
  console.log('IPC: app-version requested');
  try {
    const version = app.getVersion();
    console.log('IPC: app-version response:', version);
    return version;
  } catch (error) {
    console.error('IPC: Error getting app version:', error);
    return 'unknown';
  }
});

ipcMain.handle('platform', () => {
  console.log('IPC: platform requested');
  try {
    const platform = process.platform;
    console.log('IPC: platform response:', platform);
    return platform;
  } catch (error) {
    console.error('IPC: Error getting platform:', error);
    return 'unknown';
  }
});

ipcMain.handle('window-minimize', () => {
  if (mainWindow) {
    mainWindow.minimize();
  }
});

ipcMain.handle('window-maximize', () => {
  if (mainWindow) {
    if (mainWindow.isMaximized()) {
      mainWindow.unmaximize();
    } else {
      mainWindow.maximize();
    }
  }
});

ipcMain.handle('window-close', () => {
  if (mainWindow) {
    mainWindow.close();
  }
});

ipcMain.handle('open-dev-tools', () => {
  if (mainWindow) {
    mainWindow.webContents.openDevTools();
  }
});

// 获取资源路径
ipcMain.handle('get-resource-path', (event, relativePath) => {
  if (isDev) {
    // 开发环境下返回相对路径
    return `/${relativePath}`;
  } else {
    // 生产环境下返回正确的资源路径
    // 在打包后的应用中，资源文件位于app.asar中
    const resourcePath = path.join(__dirname, '..', relativePath);
    return `file://${resourcePath.replace(/\\/g, '/')}`;
  }
});

// 打开外部链接
ipcMain.handle('open-external', (event, url) => {
  try {
    shell.openExternal(url);
    return { success: true };
  } catch (error) {
    console.error('Error opening external URL:', error);
    return { success: false, error: error.message };
  }
});

// Storage控制器和文件对话框处理程序
ipcMain.handle('controller', async (event, { name, method, args }) => {
  if (name === 'storage') {
    return await handleStorageController(method, args);
  } else if (name === 'dialog') {
    return await handleDialogController(method, args);
  }
  throw new Error(`未知的控制器: ${name}`);
});

// Storage控制器处理函数
async function handleStorageController(method, args) {
  const Store = require('electron-store');
  const store = new Store();
  
  switch (method) {
    case 'getAllData':
      return {
        lists: store.get('todoLists', []),
        tasks: store.get('todoTasks', [])
      };
    
    case 'saveLists':
      store.set('todoLists', args.lists);
      return { success: true };
    
    case 'saveTasks':
      store.set('todoTasks', args.tasks);
      return { success: true };
    
    case 'saveAllData':
      store.set('todoLists', args.lists);
      store.set('todoTasks', args.tasks);
      return { success: true };
    
    case 'clearAllData':
      store.delete('todoLists');
      store.delete('todoTasks');
      return { success: true };
    
    case 'getStorePath':
      return { path: store.path };
    
    case 'setItem':
      store.set(args.key, args.value);
      return { success: true };
    
    case 'getItem':
      return store.get(args.key, args.defaultValue);
    
    case 'removeItem':
      store.delete(args.key);
      return { success: true };
    
    default:
      throw new Error(`未知的storage方法: ${method}`);
  }
}

// Dialog控制器处理函数
async function handleDialogController(method, args) {
  switch (method) {
    case 'showSaveDialog':
      const saveResult = await dialog.showSaveDialog(mainWindow, {
        title: '导出数据',
        defaultPath: `点点清单数据备份_${new Date().toISOString().slice(0, 10)}.ddlist`,
        filters: [
          { name: '点点清单数据文件', extensions: ['ddlist'] },
          { name: '所有文件', extensions: ['*'] }
        ]
      });
      return saveResult;
    
    case 'showOpenDialog':
      const openResult = await dialog.showOpenDialog(mainWindow, {
        title: '导入数据',
        filters: [
          { name: '点点清单数据文件', extensions: ['ddlist'] },
          { name: '所有文件', extensions: ['*'] }
        ],
        properties: ['openFile']
      });
      return openResult;
    
    case 'writeFile':
      await fs.writeFile(args.filePath, args.content, 'utf8');
      return { success: true };
    
    case 'readFile':
      const content = await fs.readFile(args.filePath, 'utf8');
      return { content };
    
    default:
      throw new Error(`未知的dialog方法: ${method}`);
  }
}

// 创建应用菜单
function createMenu() {
  const template = [
    {
      label: '文件',
      submenu: [
        {
          label: '新建任务',
          accelerator: 'CmdOrCtrl+N',
          click: () => {
            if (mainWindow) {
              mainWindow.webContents.send('menu-new-task');
            }
          }
        },
        { type: 'separator' },
        {
          label: '设置',
          accelerator: 'CmdOrCtrl+,',
          click: () => {
            if (mainWindow) {
              mainWindow.webContents.send('menu-settings');
            }
          }
        },
        { type: 'separator' },
        {
          label: '退出',
          accelerator: process.platform === 'darwin' ? 'Cmd+Q' : 'Ctrl+Q',
          click: () => {
            app.quit();
          }
        }
      ]
    },
    {
      label: '编辑',
      submenu: [
        { role: 'undo', label: '撤销' },
        { role: 'redo', label: '重做' },
        { type: 'separator' },
        { role: 'cut', label: '剪切' },
        { role: 'copy', label: '复制' },
        { role: 'paste', label: '粘贴' },
        { role: 'selectall', label: '全选' }
      ]
    },
    {
      label: '视图',
      submenu: [
        { role: 'reload', label: '重新加载' },
        { role: 'forceReload', label: '强制重新加载' },
        { role: 'toggleDevTools', label: '开发者工具' },
        { type: 'separator' },
        { role: 'resetZoom', label: '重置缩放' },
        { role: 'zoomIn', label: '放大' },
        { role: 'zoomOut', label: '缩小' },
        { type: 'separator' },
        { role: 'togglefullscreen', label: '全屏' }
      ]
    },
    {
      label: '窗口',
      submenu: [
        { role: 'minimize', label: '最小化' },
        { role: 'close', label: '关闭' }
      ]
    },
    {
      label: '帮助',
      submenu: [
        {
          label: '关于 TodoList2',
          click: () => {
            if (mainWindow) {
              mainWindow.webContents.send('menu-about');
            }
          }
        },
        {
          label: '访问GitHub',
          click: () => {
            shell.openExternal('https://github.com');
          }
        }
      ]
    }
  ];

  // macOS特殊处理
  if (process.platform === 'darwin') {
    template.unshift({
      label: app.getName(),
      submenu: [
        { role: 'about', label: '关于 ' + app.getName() },
        { type: 'separator' },
        { role: 'services', label: '服务' },
        { type: 'separator' },
        { role: 'hide', label: '隐藏 ' + app.getName() },
        { role: 'hideothers', label: '隐藏其他' },
        { role: 'unhide', label: '显示全部' },
        { type: 'separator' },
        { role: 'quit', label: '退出 ' + app.getName() }
      ]
    });
  }

  const menu = Menu.buildFromTemplate(template);
  Menu.setApplicationMenu(menu);
}



// 处理应用退出前的清理工作
app.on('before-quit', async (event) => {
  console.log('应用即将退出...');
  
  // 阻止默认退出行为，先进行数据同步
  event.preventDefault();
  
  try {
    // 触发前端数据同步
    if (mainWindow && !mainWindow.isDestroyed()) {
      console.log('触发应用关闭前数据同步...');
      
      // 发送同步请求到渲染进程并等待响应
       mainWindow.webContents.send('sync-before-quit');
       
       // 等待渲染进程完成同步
       const syncResult = await new Promise((resolve) => {
         const timeout = setTimeout(() => {
           console.warn('同步超时，强制退出');
           resolve({ success: false, error: 'timeout' });
         }, 10000); // 10秒超时
         
         ipcMain.once('sync-before-quit-complete', (event, result) => {
           clearTimeout(timeout);
           resolve(result);
         });
       });
      console.log('应用关闭前同步结果:', syncResult);
    }
  } catch (error) {
    console.warn('应用关闭前同步失败:', error);
  }
  
  // 清理主窗口
  if (mainWindow && !mainWindow.isDestroyed()) {
    mainWindow.removeAllListeners();
    if (isDev && mainWindow.webContents.isDevToolsOpened()) {
      mainWindow.webContents.closeDevTools();
    }
  }
  
  // 清理所有IPC监听器
  ipcMain.removeAllListeners();
  
  // 强制垃圾回收
  if (global.gc) {
    global.gc();
  }
  
  // 现在真正退出应用
  app.exit(0);
});

// 防止多个实例
const gotTheLock = app.requestSingleInstanceLock();

if (!gotTheLock) {
  app.quit();
} else {
  app.on('second-instance', () => {
    // 当运行第二个实例时，将焦点放在主窗口上
    if (mainWindow) {
      if (mainWindow.isMinimized()) mainWindow.restore();
      mainWindow.focus();
    }
  });
}

// 安全设置
app.on('web-contents-created', (event, contents) => {
  contents.on('new-window', (event, navigationUrl) => {
    event.preventDefault();
    shell.openExternal(navigationUrl);
  });

  contents.on('will-navigate', (event, navigationUrl) => {
    const parsedUrl = new URL(navigationUrl);
    
    if (parsedUrl.origin !== 'http://localhost:8080' && !navigationUrl.startsWith('file://')) {
      event.preventDefault();
    }
  });
});